home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / learn_f.ph < prev    next >
Text File  |  1994-04-25  |  9KB  |  256 lines
  1. /*****************************************************************************
  2.   FILE           : learn_f.ph
  3.   SHORTNAME      : learn_f
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : SNNS-Kernel Learning Functions
  7.   NOTES          : with following learning functions:
  8.                - Backpropagation
  9.                - Backpropagation with momentum term
  10.                    - Quickprop
  11.                - Counterpropagation
  12.                - BackPercolation
  13.  
  14.   AUTHOR         : Niels Mache
  15.   DATE           : 01.10.90
  16.  
  17.   CHANGED BY     : Sven Doering, Michael Vogt (Martin Reczko), Guenter Mamier
  18.   IDENTIFICATION : @(#)learn_f.ph    1.16 4/12/94
  19.   SCCS VERSION   : 1.16
  20.   LAST CHANGE    : 4/12/94
  21.  
  22.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  23.  
  24. ******************************************************************************/
  25. #ifndef _LEARN_F_DEFINED_
  26. #define  _LEARN_F_DEFINED_
  27.  
  28. /* begin global definition section */
  29. krui_err LEARN_HEBB (int start_pattern, int end_pattern,
  30.                      float *parameterInArray, int NoOfInParams, 
  31.                      float **parameterOutArray, int *NoOfOutParams);
  32.  
  33. krui_err LEARN_RM_delta (int start_pattern, int end_pattern,
  34.              float parameterInArray[], int NoOfInParams,
  35.              float * *parameterOutArray, int *NoOfOutParams    );
  36.  
  37. krui_err  LEARN_ART1(int start_pattern, int end_pattern,
  38.              float parameterInArray[], int NoOfInParams,
  39.              float * *parameterOutArray, int *NoOfOutParams);
  40.  
  41. krui_err  LEARN_ART2(int start_pattern, int end_pattern, 
  42.              float parameterInArray[], int NoOfInParams,
  43.              float * *parameterOutArray, int *NoOfOutParams);
  44.  
  45. krui_err  LEARN_ARTMAP(int start_pattern, int end_pattern,
  46.                float parameterInArray[], int NoOfInParams,
  47.                float * *parameterOutArray, int *NoOfOutParams);
  48.  
  49. krui_err  LEARN_kohonen(int start_pattern, int end_pattern,
  50.             float parameterInArray[], int NoOfInParams,
  51.             float * *parameterOutArray, int *NoOfOutParams);
  52.  
  53. krui_err  LEARN_backprop(int start_pattern, int end_pattern, 
  54.              float *parameterInArray, int NoOfInParams, 
  55.              float **parameterOutArray, int *NoOfOutParams);
  56.  
  57. krui_err  LEARN_backpropBatch(int start_pattern, int end_pattern, 
  58.                   float *parameterInArray, int NoOfInParams, 
  59.                   float **parameterOutArray, int *NoOfOutParams);
  60.  
  61. krui_err  LEARN_backpropMomentum(int start_pattern, int end_pattern, 
  62.                  float *parameterInArray, int NoOfInParams, 
  63.                  float **parameterOutArray, int *NoOfOutParams);
  64.  
  65. krui_err LEARN_quickprop(int start_pattern, int end_pattern, 
  66.              float *parameterInArray, int NoOfInParams, 
  67.              float **parameterOutArray, int *NoOfOutParams);
  68.  
  69. krui_err  LEARN_CPN(int start_pattern, int end_pattern, 
  70.             float *parameterInArray, int NoOfInParams, 
  71.             float **parameterOutArray, int *NoOfOutParams);
  72.  
  73. krui_err  LEARN_perc(int start_pattern, int end_pattern, 
  74.              float *parameterInArray, int NoOfInParams, 
  75.              float **parameterOutArray, int *NoOfOutParams);
  76.  
  77. krui_err  RbfLearnClean(void);
  78.  
  79. krui_err  RbfLearnForward(int pattern_no, int sub_pat_no);
  80.  
  81. float RbfLearnAdjustDelta(float para_center, float para_bias, 
  82.               float para_weight, float para_pain, 
  83.               float para_momentum, float para_delta_max, 
  84.               int learn_mask);
  85.  
  86. void RbfLearnAdjustWeights(float para_center, float para_bias, 
  87.                float para_weight, float para_momentum);
  88.  
  89. krui_err RbfTopoCheck(void);
  90.  
  91. krui_err  LEARN_RBF(int start_pattern, int end_pattern, 
  92.             float *parameterInArray, int NoOfInParams, 
  93.             float **parameterOutArray, int *NoOfOutParams);
  94.  
  95. krui_err LEARN_rprop(int start_pattern, int end_pattern, 
  96.              float *parameterInArray, int NoOfInParams, 
  97.              float **parameterOutArray, int *NoOfOutParams);
  98.  
  99. krui_err  LEARN_BPTT(int start_pattern, int end_pattern, 
  100.              float *parameterInArray, int NoOfInParams, 
  101.              float **parameterOutArray, int *NoOfOutParams);
  102.  
  103. krui_err  LEARN_BBPTT(int start_pattern, int end_pattern, 
  104.               float *parameterInArray, int NoOfInParams, 
  105.               float **parameterOutArray, int *NoOfOutParams);
  106.  
  107. krui_err  LEARN_QPTT(int start_pattern, int end_pattern, 
  108.              float *parameterInArray, int NoOfInParams, 
  109.              float **parameterOutArray, int *NoOfOutParams);
  110.  
  111. krui_err  LEARN_JE_Backprop(int start_pattern, int end_pattern,
  112.                 float *parameterInArray, int NoOfInParams,
  113.                 float **parameterOutArray, int *NoOfOutParams) ;
  114.  
  115. krui_err LEARN_JE_BackpropMomentum(int start_pattern, int end_pattern,
  116.                    float *parameterInArray, int NoOfInParams,
  117.                    float **parameterOutArray, 
  118.                    int *NoOfOutParams);
  119.  
  120. krui_err  LEARN_JE_Quickprop(int start_pattern, int end_pattern,
  121.                  float *parameterInArray, int NoOfInParams,
  122.                  float **parameterOutArray, int *NoOfOutParams);
  123.  
  124. krui_err  LEARN_JE_Rprop(int start_pattern, int end_pattern,
  125.              float *parameterInArray, int NoOfInParams,
  126.              float **parameterOutArray, int *NoOfOutParams) ;
  127.  
  128. krui_err  spanning_tree(void);
  129.  
  130. /* end global definition section */
  131.  
  132. /* begin private definition section */
  133.  
  134.  
  135. #define  NET_ERROR( param )      param[ 0 ]  /* returns the net error   */
  136. #define  LEARN_PARAM1( param )   param[ 0 ]  /* contains 1st learning param  */
  137. #define  LEARN_PARAM2( param )   param[ 1 ]  /* contains 2nd learning param  */
  138. #define  LEARN_PARAM3( param )   param[ 2 ]  /* contains 3rd learning param  */
  139. #define  LEARN_PARAM4( param )   param[ 3 ]  /* contains 4th learning param  */
  140. #define  LEARN_PARAM5( param )   param[ 4 ]  /* contains 5th learning param  */
  141.  
  142. #define  SIGMOID_PRIME_OFFSET    0.1         /* for modified sigmoid function */
  143. #define SQR(x)  (x) * (x)
  144.  
  145. static int  NoOfLearnedPatterns;
  146.  
  147. static float Hebb_error(int NoOfTimes);
  148.  
  149. static void RM_propagate(int pattern_no, int sub_pat_no, float prop_step);
  150.  
  151. static void RM_learn(float learn_parameter);
  152.  
  153. static krui_err put_ART1_in_pattern(int pattern_no, int sub_pat_no, 
  154.                     TopoPtrArray topo_inp_ptr);
  155.  
  156. static krui_err adjust_ART1_weights(double beta, TopoPtrArray  comp_ptr,
  157.                     TopoPtrArray delay_ptr,
  158.                     struct Unit   *winner_ptr);
  159.  
  160. static krui_err put_ART2_in_pattern(int pattern_no, int sub_pat_no,
  161.                     TopoPtrArray topo_inp_ptr);
  162.  
  163. static krui_err adjust_ART2_weights(double param_d, TopoPtrArray  p_ptr,
  164.                     struct Unit *winner_ptr);
  165.  
  166. static krui_err put_ARTMAP_in_pattern(int pattern_no, int sub_pat_no,
  167.                       TopoPtrArray topo_inpa_ptr,
  168.                       TopoPtrArray topo_inpb_ptr);
  169.  
  170. static krui_err adjust_ARTMAP_weights(double beta_a, double beta_b,
  171.                       TopoPtrArray compa_ptr,
  172.                       TopoPtrArray  compb_ptr,
  173.                       TopoPtrArray  dela_ptr,
  174.                       TopoPtrArray  delb_ptr,
  175.                       TopoPtrArray  map_ptr,
  176.                       struct Unit *winner_ptr_a,
  177.                       struct Unit *winner_ptr_b);
  178.  
  179. static    void  propagateNetForward(int pattern_no, int sub_pat_no);
  180.  
  181. static    float propagateNetBackward2(int pattern_no, int sub_pat_no, 
  182.                     float learn_parameter, float delta_max);
  183.  
  184. static    float propagateNetBackwardBatch(int pattern_no, int sub_pat_no, 
  185.                     float delta_max);
  186.  
  187. static krui_err clearDeltas(void);
  188.  
  189. static krui_err updateWeights(float eta);
  190.  
  191. static krui_err initializeBackpropMomentum(void);
  192.  
  193. static    float Backprop_momentum_FSE(int pattern_no, int sub_pat_no, 
  194.                     float learn_parameter, float mu, 
  195.                     float FSE_term, float delta_max);
  196.  
  197. static krui_err initializeQuickprop(void);
  198.  
  199. static float  propagateNetBackwardQuickprop(int pattern_no, int sub_pat_no,
  200.                         float delta_max);
  201.  
  202. static void MODI_quickprop(float learn_parameter, float max_factor, 
  203.                float decay);
  204.  
  205. static krui_err  initializeCPN(void);
  206.  
  207. static void normalize_weight(struct Unit *winner_ptr, float sum);
  208.  
  209. static void normalize_inputvector(float sum);
  210.  
  211. static float propagateNet_CPN(int pattern_no, int sub_pat_no,
  212.                   float alpha, float beta, float threshold);
  213.  
  214. static    void  propagateNetForward_perc(int pattern_no, int sub_pat_no);
  215.  
  216. static    float propagateNetBackward_perc(int pattern_no, int sub_pat_no,
  217.                     float learn_parameter, float delta_max,
  218.                     float *perc_error);
  219.  
  220. static void MODI_rprop(float maxeps);
  221.  
  222. static krui_err initializeRprop(float update_val);
  223.  
  224. static float propagateNetBackwardRprop(int pattern_no, int sub_pat_no);
  225.  
  226. static krui_err BPTT_clear_deltaw(void);
  227.  
  228. static krui_err initializeBPTT(void);
  229.  
  230. static void BPTT_propagateNetForward(int pattern_no, int sub_pat_no, int nhist);
  231.  
  232. static float initOldDeltas(int pattern_no, int sub_pat_no );
  233.  
  234. static float oneStepBackprop(int backstep, int pattern_no, int sub_pat_no, 
  235.                  int nhist);
  236.  
  237. static void BPTTadapt(float step_size, float bptt_momentum);
  238.  
  239. static float BPTT_propagateNetBackward(int pattern_no, int sub_pat_no, 
  240.                        int nhist);
  241.  
  242. static float propagateNet_kohonen(int pattern_no, int sub_pat_no, float height,
  243.                   float width, int sizehor);
  244.  
  245. static krui_err initializeKohonenLearning(void);
  246.  
  247. static void update_je_context_units(int pattern_no, int sub_pat_no) ; 
  248.  
  249. static void reset_je_context_units(void) ;
  250.  
  251. static krui_err check_je_network(void) ;
  252.  
  253. /* end private definition section */
  254.  
  255. #endif 
  256.